(function(modules) {
    // 01定义对象用于将来缓存被加载过的对象
    let installedModules = {}

    // 02定义__webpack_require__方法来替换  import  require 加载操作
    function __webpack_require__(moduleId) {
        // 判断当前缓存中是否有要被加载的内容，如果存在则直接返回
        if(installedModules[moduleId]) {
            return installedModules[moduleId].exports
        }

        // 如果当前缓存中不存在则需要我们自己定义{} 执行被导入的模块内容加载
        let module = installedModules[moduleId] = {
            i: moduleId,
            l: false,
            exports: {}
        }

        // 调用当前moduleId 对应的函数，然后完成内容加载
        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__)

        // 当上述的方法调用完成之后，我们就可以修改l的值用于表示当前模块内容已经加载完成了
        module.l = true

        // 
        return module.exports
    }
    // 03定义m属性用于保存modules
    __webpack_require__.m = modules

    // 04定义c属性用来保存缓存
    __webpack_require__.c = installedModules

    // 05定义o方法用来判断对象身上是否存在指定的属性
    __webpack_require__.o = function(object, property) {
        return Object.prototype.hasOwnProperty(object, property)
    }

    // 06 定义d方法 用于在对象身上添加指定的属性，同时给该属性提供一个getter
    __webpack_require__.d = function(exports, name, getter) {
        if(!__webpack_require__.o(exports, name)) {
            Object.defineProperty(exports, name, { enumerable:true, get: getter })
        }
    }

    // 07 定义r方法用于标识当前模块是es6 类型
    __webpack_require__.r = function(exports) {
        if(typeof Symbol !== 'undefined' && Symbol.toStringTag ){
            Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
        }
        Object.defineProperty(exports, '__esModule', { value: true })
    }

    // 08 定义n方法，用于设置具体的getter
    __webpack_require__.n = function(module) {
        let getter = module && module._esModule ?
            function getDefalut() { return module['default'] } :
            function getModulesExports() { return module }
        __webpack_require__.d(getter, 'a', getter)
        return getter
    }

    // 定义t方法   用于加载指定value的模块内容，之后对内容进行处理再返回

    __webpack_require__.t = function (value, mode) {
        // 01 加载value对应的模块内容 （value一般就是模块id）
        // 加载之后的内容又重新赋值给value变量
        if(mode & 1) {
            value = __webpack_require__(value)
        }

        if(mode & 8) { // 加载了可以直接返回使用的内容
            return value
        }

        if((mode & 4) && typeof value === 'object' && value && value.__esModule) {
            return value
        }

        // 如果 8 和 4 都没有成立  则需要自定义ns来通过default 属性返回内容

        let ns = Object.create(null)

        __webpack_require__.r(ns)

        Object.defineProperty(ns, 'default', { enumerable: true, value: value })
        
        if((mode & 2) && typeof value !== 'string') {
            for (var key in value) {
                __webpack_require__.d(ns, key, function(key) {
                    return value[key]
                }.bind(null, key))
            }
        }
        return ns
    }




    // 09 定义p属性，用于保存资源访问路径
    __webpack_require__.p = ""

    // 10 调用__webpack_require__方法执行模块导入与加载操作

    return __webpack_require__(__webpack_require__.s = './src/index.js')
})
    ({
        "./src/index.js":
            (function (module, exports, __webpack_require__) {
                let name = __webpack_require__.t(/*! ./login.js */ "./src/login.js", 0b0111)
                console.log('index.js内容');
                console.log(name);
            }),
        "./src/login.js":
            (function (module, exports) {
                module.exports = { abc: '拉勾啊啊啊啊啊' }
            })
    })





    /** 
     * 01 import() 可以实现指定模块懒加载
     * 02 当前懒加载的核心原理就是  jsonp
     * 03 t方法可以针对于内容进行不同的处理（处理方式处决于传入的数值 8 6 7 3 2 1）
    */

    /** 
     * 01 t方法接受两个参数，一个是value 一般用于表示被加载的模块id，第二个值 mode 是一个二进制的数值
     * 02 t方法内部做的第一件事情就是调用require方法加载value对应的模块导出，重新赋值给value
     * 03 当获取到了这个value值之后余下的 8 4 ns 2 都是对当前的内容进行加工处理，然后返回使用
     * 04 当mode & 8 成立是直接将 value返回（commonJS）
     * 05 当mode & 4 成立直接将value返回（ESModule）
     * 06 如果上述条件都不成立，还要继续处理value 定义一个ns {}
     *  6-1 如果拿到的value是一个可以直接使用的内容，例如是一个字符串，将它挂载到ns 的default属性上
     * 
    */